/**
 * 设备管理相关API接口
 */

import http from '../request.js'
import { API_ENDPOINTS } from '../config.js'

/**
 * 设备相关API模块
 * 包含设备列表、详情、创建、更新、删除、搜索等功能
 */
class DeviceAPI {
  /**
   * 获取设备列表
   * @param {Object} params 查询参数
   * @param {Number} params.page 页码，默认1
   * @param {Number} params.limit 每页数量，默认10
   * @param {String} params.keyword 关键词搜索
   * @param {String} params.location 位置筛选
   * @param {String} params.sortBy 排序字段：dailyRent/createdAt/deposit
   * @param {String} params.sortOrder 排序方向：asc/desc
   * @param {Number} params.minPrice 最低价格
   * @param {Number} params.maxPrice 最高价格
   */
  async getDeviceList(params = {}, retryCount = 0) {
    try {
      const result = await http.get(API_ENDPOINTS.DEVICES.LIST, params)
      
      // 检查是否需要重试（token刷新后）
      if (result.needRetry && retryCount < 1) {
        console.log('🔄 Token已刷新，重新获取设备列表...')
        return await this.getDeviceList(params, retryCount + 1)
      }
      
      return result
    } catch (error) {
      console.error('获取设备列表失败:', error)
      throw error
    }
  }

  /**
   * 获取设备详情
   * @param {String} deviceId 设备ID
   */
  async getDeviceDetail(deviceId, retryCount = 0) {
    try {
      const result = await http.get(`${API_ENDPOINTS.DEVICES.DETAIL}/${deviceId}`)
      
      // 检查是否需要重试（token刷新后）
      if (result.needRetry && retryCount < 1) {
        console.log('🔄 Token已刷新，重新获取设备详情...')
        return await this.getDeviceDetail(deviceId, retryCount + 1)
      }
      
      return result
    } catch (error) {
      console.error('获取设备详情失败:', error)
      throw error
    }
  }

  /**
   * 创建设备
   * @param {Object} data 设备数据
   * @param {String} data.title 设备标题
   * @param {String} data.description 设备描述
   * @param {String} data.brand 品牌
   * @param {String} data.model 型号
   * @param {Object} data.specifications 设备规格参数
   * @param {Array} data.images 设备图片URL数组
   * @param {Number} data.dailyRent 日租金
   * @param {Number} data.deposit 押金
   * @param {Object} data.location 位置信息
   * @param {Number} data.minRentDays 最少租赁天数
   * @param {Number} data.maxRentDays 最多租赁天数
   */
  async createDevice(data) {
    try {
      const result = await http.post(API_ENDPOINTS.DEVICES.CREATE, data)
      return result
    } catch (error) {
      console.error('创建设备失败:', error)
      throw error
    }
  }

  /**
   * 更新设备
   * @param {String} deviceId 设备ID
   * @param {Object} data 更新数据
   */
  async updateDevice(deviceId, data) {
    try {
      const result = await http.put(`${API_ENDPOINTS.DEVICES.UPDATE}/${deviceId}`, data)
      return result
    } catch (error) {
      console.error('更新设备失败:', error)
      throw error
    }
  }

  /**
   * 删除设备
   * @param {String} deviceId 设备ID
   */
  async deleteDevice(deviceId) {
    try {
      const result = await http.delete(`${API_ENDPOINTS.DEVICES.DELETE}/${deviceId}`)
      return result
    } catch (error) {
      console.error('删除设备失败:', error)
      throw error
    }
  }

  /**
   * 搜索设备
   * @param {Object} params 搜索参数
   * @param {String} params.keyword 关键词
   * @param {String} params.city 城市
   * @param {Array} params.brands 品牌数组
   * @param {Object} params.priceRange 价格范围 {min, max}
   * @param {Object} params.location 地理位置 {lat, lng, radius}
   */
  async searchDevices(params, retryCount = 0) {
    try {
      const result = await http.get(API_ENDPOINTS.DEVICES.SEARCH, params)
      
      // 检查是否需要重试（token刷新后）
      if (result.needRetry && retryCount < 1) {
        console.log('🔄 Token已刷新，重新搜索设备...')
        return await this.searchDevices(params, retryCount + 1)
      }
      
      return result
    } catch (error) {
      console.error('搜索设备失败:', error)
      throw error
    }
  }

  /**
   * 获取我的设备列表（出租方）
   * @param {Object} params 查询参数
   */
  async getMyDevices(params = {}, retryCount = 0) {
    try {
      const result = await http.get('/devices/my', params)
      
      // 检查是否需要重试（token刷新后）
      if (result.needRetry && retryCount < 1) {
        console.log('🔄 Token已刷新，重新获取我的设备...')
        return await this.getMyDevices(params, retryCount + 1)
      }
      
      return result
    } catch (error) {
      console.error('获取我的设备失败:', error)
      throw error
    }
  }

  /**
   * 更新设备状态
   * @param {String} deviceId 设备ID
   * @param {String} status 设备状态：AVAILABLE/RENTED/MAINTENANCE/OFFLINE
   */
  async updateDeviceStatus(deviceId, status) {
    try {
      const result = await http.put(`/devices/${deviceId}/status`, { status })
      return result
    } catch (error) {
      console.error('更新设备状态失败:', error)
      throw error
    }
  }

  /**
   * 获取设备统计信息
   */
  async getDeviceStats() {
    try {
      const result = await http.get('/devices/stats')
      return result
    } catch (error) {
      console.error('获取设备统计失败:', error)
      throw error
    }
  }

  /**
   * 获取热门设备推荐
   * @param {Number} limit 返回数量，默认10
   */
  async getPopularDevices(limit = 10) {
    try {
      const result = await http.get('/devices/popular', { limit })
      return result
    } catch (error) {
      console.error('获取热门设备失败:', error)
      throw error
    }
  }

  /**
   * 获取附近的设备
   * @param {Number} lat 纬度
   * @param {Number} lng 经度
   * @param {Number} radius 搜索半径（公里），默认10
   * @param {Number} limit 返回数量，默认20
   */
  async getNearbyDevices(lat, lng, radius = 10, limit = 20) {
    try {
      const result = await http.get('/devices/nearby', {
        lat,
        lng,
        radius,
        limit
      })
      return result
    } catch (error) {
      console.error('获取附近设备失败:', error)
      throw error
    }
  }

  /**
   * 获取设备品牌列表
   */
  async getDeviceBrands() {
    try {
      const result = await http.get('/devices/brands')
      return result
    } catch (error) {
      console.error('获取设备品牌失败:', error)
      throw error
    }
  }

  /**
   * 获取设备类型/分类
   */
  async getDeviceCategories() {
    try {
      const result = await http.get('/devices/categories')
      return result
    } catch (error) {
      console.error('获取设备分类失败:', error)
      throw error
    }
  }

  /**
   * 获取设备图片上传凭证
   * @param {String} filename 文件名
   * @param {String} fileType 文件类型
   */
  async getUploadCredentials(filename, fileType) {
    try {
      const result = await http.post('/devices/upload-credentials', {
        filename,
        fileType
      })
      return result
    } catch (error) {
      console.error('获取上传凭证失败:', error)
      throw error
    }
  }

  /**
   * 上传设备图片
   * @param {String} filePath 本地文件路径
   * @param {Object} uploadData 上传参数
   */
  async uploadDeviceImage(filePath, uploadData = {}) {
    try {
      const result = await http.upload('/devices/upload-image', filePath, uploadData)
      return result
    } catch (error) {
      console.error('上传设备图片失败:', error)
      throw error
    }
  }

  /**
   * 删除设备图片
   * @param {String} imageUrl 图片URL
   */
  async deleteDeviceImage(imageUrl) {
    try {
      const result = await http.delete('/devices/delete-image', {
        data: { imageUrl }
      })
      return result
    } catch (error) {
      console.error('删除设备图片失败:', error)
      throw error
    }
  }

  /**
   * 举报设备
   * @param {String} deviceId 设备ID
   * @param {String} reason 举报原因
   * @param {String} description 详细描述
   */
  async reportDevice(deviceId, reason, description) {
    try {
      const result = await http.post('/devices/report', {
        deviceId,
        reason,
        description
      })
      return result
    } catch (error) {
      console.error('举报设备失败:', error)
      throw error
    }
  }

  /**
   * 检查设备可租赁性
   * @param {String} deviceId 设备ID
   * @param {String} startDate 开始日期
   * @param {String} endDate 结束日期
   */
  async checkAvailability(deviceId, startDate, endDate) {
    try {
      const result = await http.get('/devices/check-availability', {
        deviceId,
        startDate,
        endDate
      })
      return result
    } catch (error) {
      console.error('检查设备可用性失败:', error)
      throw error
    }
  }

  /**
   * 获取设备租赁历史
   * @param {String} deviceId 设备ID
   * @param {Object} params 查询参数
   */
  async getDeviceRentHistory(deviceId, params = {}) {
    try {
      const result = await http.get(`/devices/${deviceId}/rent-history`, params)
      return result
    } catch (error) {
      console.error('获取设备租赁历史失败:', error)
      throw error
    }
  }

  /**
   * 获取设备评价
   * @param {String} deviceId 设备ID
   * @param {Object} params 查询参数
   */
  async getDeviceReviews(deviceId, params = {}) {
    try {
      const result = await http.get(`/devices/${deviceId}/reviews`, params)
      return result
    } catch (error) {
      console.error('获取设备评价失败:', error)
      throw error
    }
  }

  /**
   * 批量操作设备
   * @param {Array} deviceIds 设备ID数组
   * @param {String} action 操作类型：delete/updateStatus/updateOwner
   * @param {Object} params 操作参数
   */
  async batchOperation(deviceIds, action, params = {}) {
    try {
      const result = await http.post('/devices/batch-operation', {
        deviceIds,
        action,
        params
      })
      return result
    } catch (error) {
      console.error('批量操作设备失败:', error)
      throw error
    }
  }

  /**
   * 获取设备管理统计数据（管理员）
   * @param {Object} params 查询参数
   */
  async getManagementStats(params = {}) {
    try {
      const result = await http.get('/devices/management-stats', params)
      return result
    } catch (error) {
      console.error('获取管理统计失败:', error)
      throw error
    }
  }

  /**
   * 导出设备数据（管理员）
   * @param {Object} params 导出参数
   */
  async exportDevices(params = {}) {
    try {
      const result = await http.get('/devices/export', params)
      return result
    } catch (error) {
      console.error('导出设备数据失败:', error)
      throw error
    }
  }

  /**
   * 添加收藏
   * @param {String} deviceId 设备ID
   */
  async addFavorite(deviceId) {
    try {
      const result = await http.post(`/favorites/${deviceId}`)
      return result
    } catch (error) {
      console.error('添加收藏失败:', error)
      throw error
    }
  }

  /**
   * 取消收藏
   * @param {String} deviceId 设备ID
   */
  async removeFavorite(deviceId) {
    try {
      const result = await http.delete(`/favorites/${deviceId}`)
      return result
    } catch (error) {
      console.error('取消收藏失败:', error)
      throw error
    }
  }

  /**
   * 获取收藏列表
   * @param {Object} params 查询参数
   */
  async getFavoriteList(params = {}, retryCount = 0) {
    try {
      const result = await http.get('/favorites', params)
      
      // 检查是否需要重试（token刷新后）
      if (result.needRetry && retryCount < 1) {
        console.log('🔄 Token已刷新，重新获取收藏列表...')
        return await this.getFavoriteList(params, retryCount + 1)
      }
      
      return result
    } catch (error) {
      console.error('获取收藏列表失败:', error)
      throw error
    }
  }

  /**
   * 检查设备收藏状态
   * @param {String} deviceId 设备ID
   */
  async checkFavorite(deviceId) {
    try {
      const result = await http.get(`/favorites/check/${deviceId}`)
      return result
    } catch (error) {
      console.error('检查收藏状态失败:', error)
      throw error
    }
  }

  /**
   * 批量检查收藏状态
   * @param {Array} deviceIds 设备ID数组
   */
  async checkMultipleFavorites(deviceIds) {
    try {
      const result = await http.get('/favorites/check-multiple', {
        deviceIds: deviceIds.join(',')
      })
      return result
    } catch (error) {
      console.error('批量检查收藏状态失败:', error)
      throw error
    }
  }
}

// 创建实例并导出
const deviceAPI = new DeviceAPI()
export default deviceAPI 